/**
 * ClassName: PersonTest
 * Description:
 *
 * @Author liu
 * @Create 2024/11/27 21:47
 * @Version 1.0
 */
public class test1 {
}

//709.转换成小写字母
//给你一个字符串 s ，将该字符串中的大写字母转换成相同的小写字母，返回新的字符串。
//
//
//
//示例 1：
//
//输入：s = "Hello"
//输出："hello"
//示例 2：
//
//输入：s = "here"
//输出："here"
//示例 3：
//
//输入：s = "LOVELY"
//输出："lovely"

class Solution {
    public String toLowerCase(String s) {
        StringBuilder sb = new StringBuilder();//sb
        for(int i= 0;i<s.length();i++){
            //charAt():获取指定索引处的字符。
            char ch = s.charAt(i);
            if(ch >=65 && ch <=90){
                //大写变小写 |=32
                //小写变大写 &=-33
                //相互变 ^=32
                ch |=32;
            }
            //append(): 将指定字符串、字符、布尔值或其他数据类型的表示追加到字符串缓冲区的末尾。
            sb.append(ch);
        }
        //toString():将字符串缓冲区中的字符序列转换为字符串
        return sb.toString();

    }
}


//2的幂
//给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。
//
//如果存在一个整数 x 使得 n == 2x ，则认为 n 是 2 的幂次方。
//
// 示例 1：
//
//输入：n = 1
//输出：true
//解释：20 = 1
//示例 2：
//
//输入：n = 16
//输出：true
//解释：24 = 16
//示例 3：
//
//输入：n = 3
//输出：false

class Solution2 {
    public boolean isPowerOfTwo(int n) {
        return n>0&&(n&(n-1))==0;

    }
}



//1470.重新排列数组
//给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,...,xn,y1,y2,...,yn] 的格式排列。
//
//请你将数组按 [x1,y1,x2,y2,...,xn,yn] 格式重新排列，返回重排后的数组。
//
//
//
//示例 1：
//
//输入：nums = [2,5,1,3,4,7], n = 3
//输出：[2,3,5,4,1,7]
//解释：由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ，所以答案为 [2,3,5,4,1,7]
//示例 2：
//
//输入：nums = [1,2,3,4,4,3,2,1], n = 4
//输出：[1,4,2,3,3,2,4,1]
//示例 3：
//
//输入：nums = [1,1,2,2], n = 2
//输出：[1,2,1,2]
//
class Solution3{
    public int[] shuffle(int[] nums, int n) {
        int[] arr=new int[2*n];
        int i=0,j=n;
        for(int k =0;k<2*n;k++){
            arr[k]=k % 2 == 0 ? nums[i++]:nums[j++];
        }
        return arr;
    }
}


//867.转置矩阵
//给你一个二维整数数组 matrix， 返回 matrix 的 转置矩阵 。
//
//矩阵的 转置 是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。

//示例 1：
//
//输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
//输出：[[1,4,7],[2,5,8],[3,6,9]]
//示例 2：
//
//输入：matrix = [[1,2,3],[4,5,6]]
//输出：[[1,4],[2,5],[3,6]]

class Solution5 {
    public int[][] transpose(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] reMa = new int[n][m];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                reMa[j][i]= matrix[i][j];
            }
        }
        return reMa;
    }
}



//2586.统计范围内的元音字符串书
//给你一个下标从 0 开始的字符串数组 words 和两个整数：left 和 right 。
//
//如果字符串以元音字母开头并以元音字母结尾，那么该字符串就是一个 元音字符串 ，其中元音字母是 'a'、'e'、'i'、'o'、'u' 。
//
//返回 words[i] 是元音字符串的数目，其中 i 在闭区间 [left, right] 内。
//
//
//
//示例 1：
//
//输入：words = ["are","amy","u"], left = 0, right = 2
//输出：2
//解释：
//- "are" 是一个元音字符串，因为它以 'a' 开头并以 'e' 结尾。
//- "amy" 不是元音字符串，因为它没有以元音字母结尾。
//- "u" 是一个元音字符串，因为它以 'u' 开头并以 'u' 结尾。
//在上述范围中的元音字符串数目为 2 。
//示例 2：
//
//输入：words = ["hey","aeo","mu","ooo","artro"], left = 1, right = 4
//输出：3
//解释：
//- "aeo" 是一个元音字符串，因为它以 'a' 开头并以 'o' 结尾。
//- "mu" 不是元音字符串，因为它没有以元音字母开头。
//- "ooo" 是一个元音字符串，因为它以 'o' 开头并以 'o' 结尾。
//- "artro" 是一个元音字符串，因为它以 'a' 开头并以 'o' 结尾。
//在上述范围中的元音字符串数目为 3 。
//

class Solution6 {
    private static final String VOWEL ="aeiou";
    public int vowelStrings(String[] words, int left, int right) {
        int ans = 0;
        for(int i=left;i<=right;i++){
            String s=words[i];
            if(VOWEL.indexOf(s.charAt(0)) !=-1 && VOWEL.indexOf(s.charAt(s.length()-1)) !=-1){
                ans++;
            }

        }
        return ans;
    }
}


//852.山脉数组的峰顶索引
//给定一个长度为 n 的整数 山脉 数组 arr ，其中的值递增到一个 峰值元素 然后递减。
//
//返回峰值元素的下标。
//
//你必须设计并实现时间复杂度为 O(log(n)) 的解决方案。
//
//
//
//示例 1：
//
//输入：arr = [0,1,0]
//输出：1
//示例 2：
//
//输入：arr = [0,2,1,0]
//输出：1
//示例 3：
//
//输入：arr = [0,10,5,2]
//输出：1
//
class Solution7 {
    public int peakIndexInMountainArray(int[] arr) {
        //开区间
        //[1,n-2]
        //(0,n-2)
        int left =0;
        int rigth = arr.length-2;
        //二分
        while(left+1<rigth){
            int mid =left+(rigth -left)/2;
            if(arr[mid]>=arr[mid+1]){
                rigth = mid;

            }else{
                left = mid;
            }
        }
        return rigth;
    }
}



//1768.交替合并字符串
//给你两个字符串 word1 和 word2 。请你从 word1 开始，通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长，就将多出来的字母追加到合并后字符串的末尾。
//
//返回 合并后的字符串 。
//
//
//
//示例 1：
//
//输入：word1 = "abc", word2 = "pqr"
//输出："apbqcr"
//解释：字符串合并情况如下所示：
//word1：  a   b   c
//word2：    p   q   r
//合并后：  a p b q c r
//示例 2：
//
//输入：word1 = "ab", word2 = "pqrs"
//输出："apbqrs"
//解释：注意，word2 比 word1 长，"rs" 需要追加到合并后字符串的末尾。
//word1：  a   b
//word2：    p   q   r   s
//合并后：  a p b q   r   s
//示例 3：
//
//输入：word1 = "abcd", word2 = "pq"
//输出："apbqcd"
//解释：注意，word1 比 word2 长，"cd" 需要追加到合并后字符串的末尾。
//word1：  a   b   c   d
//word2：    p   q
//合并后：  a p b q c   d

class Solution8 {
    public String mergeAlternately(String word1, String word2) {
        int n = word1.length();
        int m = word2.length();
        StringBuilder ans = new StringBuilder(n+m);
        for(int i=0;i<n||i<m;i++){//i<n||i<m,是条件，字符长，加到后面
            if(i<n){
                ans.append(word1.charAt(i));//append()函数，可以向列表末尾添加元素
            }
            if(i<m){
                ans.append(word2.charAt(i));
            }
        }
        return ans.toString();
    }
}

//389.找不同
//给定两个字符串 s 和 t ，它们只包含小写字母。
//
//字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。
//
//请找出在 t 中被添加的字母。
//
//
//
//示例 1：
//
//输入：s = "abcd", t = "abcde"
//输出："e"
//解释：'e' 是那个被添加的字母。
//示例 2：
//
//输入：s = "", t = "y"
//输出："y"
//
class Solution9 {
    public char findTheDifference(String s, String t) {
        int ret = 0;
        for(int i = 0;i<s.length();i++){
            ret ^=s.charAt(i);
        }
        for(int i = 0;i<t.length();i++){
            ret ^=t.charAt(i);
        }
        return (char)ret;
    }
}